{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * revised and tuned configuration, updated views\n",
    " * training on full dataset (including Y3, new light curves, fixes)\n",
    " * trained with updated star radius estimations, multiple duplicates removed\n",
    " * removed instar examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/1/AstroCNNModel_extended_20220327_224202',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/2/AstroCNNModel_extended_20220327_231753',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/3/AstroCNNModel_extended_20220327_235217',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/4/AstroCNNModel_extended_20220328_002724',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/5/AstroCNNModel_extended_20220328_010226',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/6/AstroCNNModel_extended_20220328_013707',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/7/AstroCNNModel_extended_20220328_021128',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/8/AstroCNNModel_extended_20220328_024549',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/9/AstroCNNModel_extended_20220328_032003',\n",
       " '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1/10/AstroCNNModel_extended_20220328_035419']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/ext_35-y2o_run_1'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-35-y2o-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v12-y2-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "2205 records\n",
      "Running model 2\n",
      "2205 records\n",
      "Running model 3\n",
      "2205 records\n",
      "Running model 4\n",
      "2205 records\n",
      "Running model 5\n",
      "2205 records\n",
      "Running model 6\n",
      "2205 records\n",
      "Running model 7\n",
      "2205 records\n",
      "Running model 8\n",
      "2205 records\n",
      "Running model 9\n",
      "2205 records\n",
      "Running model 10\n",
      "2205 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_e', 'disp_n', 'disp_j', 'disp_s', 'disp_b']\n",
    "\n",
    "col_e = labels.index('disp_e')\n",
    "thresh = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_e')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "for l in labels:\n",
    "    tce_table[l] = tce_table[l[:-1] + l[-1].upper()]\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9737991266375546\n",
      "Precision: 0.7559322033898305\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_e_p'] > 0)\n",
    "pos = (pl['disp_e'] > 0)\n",
    "\n",
    "pneg = (pl['disp_e_p'] == 0)\n",
    "neg = (pl['disp_e'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "334227600\n",
      "118412801\n",
      "141753278\n",
      "158159741\n",
      "276978548\n",
      "404220255\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "283330382\n",
      "14209654\n",
      "185607431\n",
      "199376584\n",
      "267924099\n",
      "356776209\n",
      "136651206\n",
      "154214348\n",
      "277848886\n",
      "278555119\n",
      "278910035\n",
      "357302392\n",
      "395164445\n",
      "417208086\n",
      "252588526\n",
      "431338538\n",
      "192591652\n",
      "468608862\n",
      "127846210\n",
      "269291226\n",
      "164528404\n",
      "18178958\n",
      "237278147\n",
      "27896467\n",
      "356822358\n",
      "359312744\n",
      "405687343\n",
      "308805406\n",
      "408945155\n",
      "648359612\n",
      "82242456\n",
      "56861756\n",
      "91987762\n",
      "138847344\n",
      "290991351\n",
      "97487520\n",
      "154271808\n",
      "159636125\n",
      "399167691\n",
      "230197530\n",
      "284266496\n",
      "298647682\n",
      "123489614\n",
      "167309408\n",
      "183076970\n",
      "183978683\n",
      "201601338\n",
      "21601170\n",
      "276738707\n",
      "281578420\n",
      "291374558\n",
      "293527927\n",
      "299945796\n",
      "300153494\n",
      "309650507\n",
      "311103813\n",
      "319865847\n",
      "320356995\n",
      "326693475\n",
      "363404187\n",
      "373919592\n",
      "379191982\n",
      "384341508\n",
      "38679633\n",
      "404733023\n",
      "404851508\n",
      "404851552\n",
      "404851966\n",
      "40602499\n",
      "406971913\n",
      "407615704\n",
      "62807165\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 340066802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e_p</th>\n",
       "      <th>disp_n_p</th>\n",
       "      <th>disp_j_p</th>\n",
       "      <th>disp_s_p</th>\n",
       "      <th>disp_b_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e_p, disp_n_p, disp_j_p, disp_s_p, disp_b_p, maxcount, disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 340066802]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_e']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = int(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.968331166078948, max R: 1.0, max P: 1.0\n",
      "100% recall at: 50%, threshold: 0.015999701976830705\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    ps.append(p)\n",
    "    rs.append(r)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
